// 导入智谱AI模块
const zhipuAI = require('../../utils/zhipu_ai');

Page({
  /**
   * 页面的初始数据
   */
  data: {
    // 职业兴趣评估数据
    userTags: ['创造力', '逻辑思维', '沟通', '计算机'],
    showInterestTags: false,
    showInterestResults: false,
    currentQuestion: null,
    currentQuestionIndex: 0,
    totalQuestions: 5,
    // 将单个加载状态拆分为多个独立的状态
    isLoadingCareer: false,  // 职业匹配加载状态
    isLoadingResume: false,  // 简历分析加载状态
    isLoadingInterview: false, // 面试模拟加载状态
    isLoadingIndustry: false,  // 行业趋势加载状态
    questions: [
      {
        text: '你更喜欢哪种工作方式？',
        options: [
          { text: '独立思考，解决逻辑问题', value: 'logical' },
          { text: '与团队协作，共同完成项目', value: 'teamwork' },
          { text: '创意设计，开发新点子', value: 'creative' },
          { text: '有条理地管理和组织任务', value: 'organized' }
        ]
      },
      {
        text: '遇到问题时，你通常会怎么做？',
        options: [
          { text: '分析问题，寻找最佳解决方案', value: 'analytical' },
          { text: '寻求他人帮助和建议', value: 'collaborative' },
          { text: '尝试创新的方法解决', value: 'innovative' },
          { text: '按照既定流程处理', value: 'procedural' }
        ]
      },
      {
        text: '你更喜欢使用哪些工具？',
        options: [
          { text: '编程和开发工具', value: 'technical' },
          { text: '数据分析和统计软件', value: 'analytical' },
          { text: '设计和创作工具', value: 'creative' },
          { text: '沟通和协作平台', value: 'communicative' }
        ]
      },
      {
        text: '你期望的工作环境是？',
        options: [
          { text: '创业型，充满活力和挑战', value: 'startup' },
          { text: '大型企业，稳定有序', value: 'corporate' },
          { text: '自由灵活，可远程工作', value: 'flexible' },
          { text: '研究型，专注于深度探索', value: 'research' }
        ]
      },
      {
        text: '你认为以下哪项最能激励你？',
        options: [
          { text: '创新和突破的机会', value: 'innovation' },
          { text: '专业能力的成长', value: 'growth' },
          { text: '对社会有积极影响', value: 'impact' },
          { text: '良好的薪资和福利', value: 'compensation' }
        ]
      }
    ],
    userAnswers: [],
    careerMatches: [],

    // AI 简历优化数据
    resumeFile: null,
    resumeAdvice: '',

    // AI 模拟面试数据
    jobPositions: ['软件工程师', '产品经理', 'UI/UX设计师', '数据分析师', '市场营销专员', '自定义'],
    jobIndex: 0,
    interviewFeedback: '',

    // AI 行业趋势分析数据
    industries: ['人工智能', '互联网', '金融科技', '生物医药', '新能源', '教育科技', '自定义'],
    industryIndex: 0,
    industryTrend: '',

    // 模拟数据标记
    isMockData: false,

    // 模拟面试对话相关
    interviewMode: false,     // 是否在面试模式
    interviewMessages: [],    // 面试对话历史 [{role: 'ai'|'user', content: '消息内容'}]
    userInput: '',            // 用户输入内容
    interviewContext: null,   // 面试上下文信息
    
    // 面试历史记录
    interviewHistory: [],     // 面试历史记录
    showInterviewHistory: false, // 是否显示面试历史
    
    // 自定义选项
    isCustomJob: false,       // 是否使用自定义岗位
    customJobName: '',        // 自定义岗位名称
    isCustomIndustry: false,  // 是否使用自定义行业
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad: function (options) {
    console.log('生涯规划助手页面加载');
    
    // 加载面试历史记录
    this.loadInterviewHistory();
  },

  /**
   * 加载面试历史记录
   */
  loadInterviewHistory: function() {
    try {
      const history = wx.getStorageSync('interview_history');
      if (history) {
        this.setData({
          interviewHistory: JSON.parse(history)
        });
      }
    } catch (e) {
      console.error('加载面试历史失败:', e);
    }
  },
  
  /**
   * 保存面试历史记录
   */
  saveInterviewHistory: function(interviewRecord) {
    try {
      // 获取现有历史记录
      let history = this.data.interviewHistory || [];
      
      // 添加新记录到历史顶部
      history.unshift(interviewRecord);
      
      // 只保留最近10条记录
      if (history.length > 10) {
        history = history.slice(0, 10);
      }
      
      // 更新状态
      this.setData({
        interviewHistory: history
      });
      
      // 保存到本地存储
      wx.setStorageSync('interview_history', JSON.stringify(history));
    } catch (e) {
      console.error('保存面试历史失败:', e);
    }
  },

  /**
   * 显示面试历史记录
   */
  showHistory: function() {
    this.setData({
      showInterviewHistory: true
    });
  },
  
  /**
   * 隐藏面试历史记录
   */
  hideHistory: function() {
    this.setData({
      showInterviewHistory: false
    });
  },
  
  /**
   * 查看历史面试记录详情
   */
  viewHistoryDetail: function(e) {
    const index = e.currentTarget.dataset.index;
    const record = this.data.interviewHistory[index];
    
    this.setData({
      interviewMessages: record.messages,
      interviewMode: true,
      interviewFeedback: record.feedback,
      isViewingHistory: true  // 标记正在查看历史
    });
  },

  /**
   * 开始职业兴趣评估
   */
  startAssessment: function () {
    this.setData({
      currentQuestion: this.data.questions[0],
      currentQuestionIndex: 0,
      userAnswers: [],
      showInterestTags: false,
      showInterestResults: false
    });
  },

  /**
   * 选择选项
   */
  selectOption: function (e) {
    const value = e.currentTarget.dataset.value;
    const userAnswers = [...this.data.userAnswers, value];
    
    if (this.data.currentQuestionIndex < this.data.totalQuestions - 1) {
      // 进入下一个问题
      this.setData({
        userAnswers,
        currentQuestionIndex: this.data.currentQuestionIndex + 1,
        currentQuestion: this.data.questions[this.data.currentQuestionIndex + 1]
      });
    } else {
      // 完成评估，生成标签
      this.generateTags(userAnswers);
    }
  },

  /**
   * 生成兴趣标签
   */
  generateTags: function (answers) {
    // 模拟生成标签的逻辑
    const tagMapping = {
      logical: '逻辑思维',
      teamwork: '团队协作',
      creative: '创造力',
      organized: '组织能力',
      analytical: '分析能力',
      collaborative: '合作精神',
      innovative: '创新能力',
      procedural: '执行力',
      technical: '技术能力',
      communicative: '沟通能力',
      startup: '创业精神',
      corporate: '企业思维',
      flexible: '适应性',
      research: '研究能力',
      innovation: '创新导向',
      growth: '成长导向',
      impact: '影响力导向',
      compensation: '结果导向'
    };
    
    // 根据用户的回答生成标签
    const tags = answers.map(answer => tagMapping[answer]);
    // 添加"计算机"标签
    if (tags.includes('技术能力') || tags.includes('逻辑思维')) {
      tags.push('计算机');
    }
    
    // 保证标签唯一性
    const uniqueTags = [...new Set(tags)];
    
    this.setData({
      userTags: uniqueTags.slice(0, 4), // 最多显示4个标签
      showInterestTags: true,
      currentQuestion: null
    });
  },

  /**
   * 重置评估
   */
  resetAssessment: function () {
    this.startAssessment();
  },

  /**
   * 获取职业匹配结果
   */
  getCareerMatches: function () {
    // 准备请求消息
    const tagString = this.data.userTags.join('、');
    const userPrompt = `作为职业规划顾问，请根据我的特点标签（${tagString}）推荐最匹配的职业方向，并给出匹配度百分比。`;
    
    const messages = [
      { role: 'system', content: '你是一个专业的职业规划顾问，擅长根据用户的兴趣和能力特点推荐合适的职业方向。' },
      { role: 'user', content: userPrompt }
    ];

    // 显示加载效果 - 只更新职业匹配的加载状态
    this.setData({
      isLoadingCareer: true
    });
    
    // 调用智谱AI
    zhipuAI.callZhipuAPI(messages, {
      fallbackToMock: true,
      mockType: 'career_interest',
      onSuccess: (response, data) => {
        console.log('AI职业匹配响应成功:', response);
        
        // 将响应转换为职业匹配数据
        try {
          let careerMatches = this.parseCareerResponse(response);
          this.setData({
            careerMatches,
            showInterestResults: true,
            isMockData: data.mock === true,
            isLoadingCareer: false
          });
        } catch (error) {
          console.error('解析职业匹配失败:', error);
          // 使用默认匹配
          this.setData({
            careerMatches: [
              { job: '数据分析师/商业分析师', score: 90 },
              { job: '项目经理', score: 85 },
              { job: '市场研究分析师', score: 80 },
              { job: '咨询顾问', score: 85 },
              { job: '产品经理', score: 80 }
            ],
            showInterestResults: true,
            isMockData: true,
            isLoadingCareer: false
          });
        }
      },
      onError: (error) => {
        console.error('AI响应错误:', error);
        wx.showToast({
          title: '获取职业匹配失败',
          icon: 'none'
        });
        this.setData({
          isLoadingCareer: false
        });
      }
    });
  },
  
  /**
   * 解析AI职业响应
   */
  parseCareerResponse: function(response) {
    const careerMatches = [];
    
    try {
      // 分行处理响应
      const lines = response.split('\n');
      
      // 标记以跟踪当前正在处理的职业
      let currentJob = null;
      let currentScore = null;
      
      for (let i = 0; i < lines.length; i++) {
        const line = lines[i].trim();
        
        // 跳过空行
        if (!line) continue;
        
        // 尝试匹配Markdown格式的标题行 - "### 1. 职业名称"
        let jobMatch = line.match(/^(#+)\s*\d+\.\s*\*\*(.*?)\*\*/);
        if (!jobMatch) {
          // 尝试匹配其他格式 - "1. 职业名称"
          jobMatch = line.match(/^\d+\.\s*\*\*(.*?)\*\*/);
        }
        if (!jobMatch) {
          // 尝试匹配没有序号的标题 - "职业名称"
          jobMatch = line.match(/^\*\*(.*?)\*\*/);
        }
        
        if (jobMatch) {
          const jobName = jobMatch[jobMatch.length - 1].replace(/\*\*/g, '').trim();
          currentJob = jobName;
          continue;
        }
        
        // 匹配匹配度行
        const scoreMatch = line.match(/匹配度[：:]\s*(\d+)%/);
        if (scoreMatch && currentJob) {
          currentScore = parseInt(scoreMatch[1]);
          
          // 找到职业和匹配度，添加到结果中
          careerMatches.push({
            job: currentJob,
            score: currentScore
          });
          
          // 重置当前职业，准备处理下一个
          currentJob = null;
          currentScore = null;
        }
      }
      
      // 如果没有解析到匹配项，使用正则表达式进行全文匹配
      if (careerMatches.length === 0) {
        // 尝试直接匹配格式 "职业名称 - 匹配度：90%"
        const regex = /([^-\n:]+)(?:-|\s+)[^-\n]*匹配度[：:]\s*(\d+)%/g;
        let match;
        
        while ((match = regex.exec(response)) !== null) {
          if (match.length >= 3) {
            const job = match[1].replace(/^[0-9.#\s*]+/, '').replace(/\*\*/g, '').trim();
            const score = parseInt(match[2]);
            careerMatches.push({ job, score });
          }
        }
      }
      
      // 如果仍然没有匹配项，尝试匹配简单格式
      if (careerMatches.length === 0) {
        const lines = response.split('\n');
        for (let line of lines) {
          // 查找带有数字百分比的行
          const percentMatch = line.match(/(\d+)%/);
          if (percentMatch) {
            const score = parseInt(percentMatch[1]);
            // 提取可能的职业名称 - 通常是百分比前的文本
            let jobText = line.substring(0, line.indexOf(percentMatch[0])).trim();
            // 清理文本，去除常见前缀和标记
            jobText = jobText.replace(/^[0-9.#\s*]+/, '').replace(/\*\*/g, '').trim();
            
            if (jobText && jobText.length < 30) { // 避免提取过长的文本
              careerMatches.push({ job: jobText, score });
            }
          }
        }
      }
      
      // 如果没有解析到匹配项，使用默认值
      if (careerMatches.length === 0) {
        throw new Error('没有解析到有效的职业匹配');
      }
      
      return careerMatches;
    } catch (error) {
      console.error('解析职业匹配失败:', error);
      // 使用最新示例数据作为默认值
      return [
        { job: '数据分析师/商业分析师', score: 90 },
        { job: '项目经理', score: 85 },
        { job: '市场研究分析师', score: 80 },
        { job: '咨询顾问', score: 85 },
        { job: '产品经理', score: 80 }
      ];
    }
  },

  /**
   * 查看职业详情
   */
  viewCareerDetails: function () {
    wx.showToast({
      title: '职业详情功能开发中',
      icon: 'none'
    });
  },

  /**
   * 上传简历
   */
  uploadResume: function () {
    // 检测是否是Android平台
    const systemInfo = wx.getSystemInfoSync();
    const isAndroid = systemInfo.platform === 'android';
    
    // 提供适合当前平台的选择方式
    wx.showActionSheet({
      itemList: ['从微信聊天记录中选择文件', '从手机本地文件选择'],
      success: (res) => {
        if (res.tapIndex === 0) {
          // 从聊天记录中选择文件
          this.chooseFromMessage();
        } else if (res.tapIndex === 1) {
          // 根据平台选择合适的方法
          if (isAndroid) {
            // Android上尝试使用特殊方法
            this.chooseFromLocalAndroid();
          } else {
            this.chooseFromLocal();
          }
        }
      }
    });
  },
  
  /**
   * 从聊天记录选择文件 - 最广泛支持的方式
   */
  chooseFromMessage: function() {
    try {
      wx.chooseMessageFile({
        count: 1,
        type: 'file',
        success: (res) => {
          console.log('聊天记录文件选择成功:', res);
          if (res.tempFiles && res.tempFiles.length > 0) {
            this.handleSelectedFile(res.tempFiles[0]);
          } else {
            wx.showToast({
              title: '未选择文件',
              icon: 'none'
            });
          }
        },
        fail: (err) => {
          console.error('选择文件失败:', err);
          wx.showToast({
            title: '文件选择失败，请重试',
            icon: 'none'
          });
        }
      });
    } catch (e) {
      console.error('chooseMessageFile异常:', e);
      wx.showToast({
        title: '文件选择发生错误，请使用其他方式',
        icon: 'none',
        duration: 2000
      });
      
      // 使用模拟数据作为备用方案
      this.handleMockFileUpload();
    }
  },

  /**
   * 从本地选择文件 - 标准方式
   */
  chooseFromLocal: function() {
    try {
      wx.chooseMessageFile({
        count: 1,
        type: 'file',
        success: (res) => {
          console.log('本地文件选择成功:', res);
          if (res.tempFiles && res.tempFiles.length > 0) {
            this.handleSelectedFile(res.tempFiles[0]);
          }
        },
        fail: (err) => {
          console.error('选择文件失败:', err);
          wx.showToast({
            title: '无法选择文件，请尝试从聊天中选择',
            icon: 'none',
            duration: 2000
          });
        }
      });
    } catch (e) {
      console.error('chooseMessageFile异常:', e);
      wx.showToast({
        title: '文件选择发生错误，请使用其他方式',
        icon: 'none',
        duration: 2000
      });
      
      // 使用模拟数据作为备用方案
      this.handleMockFileUpload();
    }
  },
  
  /**
   * 为Android特别设计的文件选择方法
   */
  chooseFromLocalAndroid: function() {
    try {
      // 尝试使用chooseMedia作为备选方案
      wx.chooseMedia({
        count: 1,
        mediaType: ['file'], 
        success: (res) => {
          console.log('Android文件选择成功:', res);
          if (res.tempFiles && res.tempFiles.length > 0) {
            const file = res.tempFiles[0];
            this.handleSelectedFile({
              path: file.tempFilePath,
              size: file.size,
              name: file.tempFilePath.substring(file.tempFilePath.lastIndexOf('/') + 1)
            });
          }
        },
        fail: (err) => {
          console.error('Android选择文件失败:', err);
          
          // 再次尝试使用chooseMessageFile
          wx.showToast({
            title: '请尝试从聊天中选择文件',
            icon: 'none',
            duration: 2000
          });
          
          setTimeout(() => {
            this.chooseFromMessage();
          }, 1500);
        }
      });
    } catch (e) {
      console.error('Android文件选择异常:', e);
      
      // 直接转到聊天选择
      wx.showToast({
        title: '请从聊天记录中选择文件',
        icon: 'none',
        duration: 2000
      });
      
      setTimeout(() => {
        this.chooseFromMessage();
      }, 1500);
    }
  },
  
  /**
   * 使用模拟文件数据
   */
  handleMockFileUpload: function() {
    // 创建一个模拟文件对象
    const mockFile = {
      path: 'mock_file_path',
      name: 'resume_example.pdf',
      size: 1024 * 100, // 模拟100KB的文件
      time: new Date().getTime(),
      type: 'application/pdf'
    };
    
    wx.showModal({
      title: '无法选择文件',
      content: '由于系统限制，无法选择文件。是否使用示例简历进行AI分析？',
      confirmText: '使用示例',
      cancelText: '取消',
      success: (res) => {
        if (res.confirm) {
          this.handleSelectedFile(mockFile);
          wx.showToast({
            title: '已使用示例简历',
            icon: 'success'
          });
        }
      }
    });
  },

  /**
   * 处理选择的文件
   */
  handleSelectedFile: function(file) {
    console.log('处理选择的文件:', file);
    
    // 文件大小限制为10MB
    const maxSize = 10 * 1024 * 1024;
    if (file.size > maxSize) {
      wx.showToast({
        title: '文件大小不能超过10MB',
        icon: 'none'
      });
      return;
    }
    
    // 防止文件路径为空
    if (!file.path && file.tempFilePath) {
      file.path = file.tempFilePath;
    }
    
    // 确保文件名存在
    if (!file.name && file.path) {
      file.name = file.path.substring(file.path.lastIndexOf('/') + 1);
      // 如果文件名仍然为空，生成一个默认名称
      if (!file.name) {
        const timestamp = new Date().getTime();
        file.name = `resume_${timestamp}.pdf`;
      }
    }
    
    this.setData({ resumeFile: file });
    
    // 显示上传成功提示
    wx.showToast({
      title: '文件选择成功',
      icon: 'success'
    });
  },

  /**
   * 分析简历
   */
  analyzeResume: function () {
    if (!this.data.resumeFile) {
      wx.showToast({
        title: '请先上传简历',
        icon: 'none'
      });
      return;
    }
    
    // 显示加载效果 - 只更新简历分析的加载状态
    this.setData({
      isLoadingResume: true
    });
    
    // 由于微信小程序限制，无法直接读取文件内容
    // 这里使用模拟数据，实际开发中应上传文件到后端服务器
    
    // 获取正在应聘的岗位
    const jobPosition = this.data.isCustomJob 
      ? this.data.customJobName.trim()
      : this.data.jobPositions[this.data.jobIndex];
    
    const userPrompt = `我是一名求职${jobPosition}岗位的应聘者，我的简历文件名是${this.data.resumeFile.name}。由于技术限制无法提供具体内容，请基于这个岗位给出一些通用的简历优化建议。`;
    
    const messages = [
      { role: 'system', content: '你是一个专业的简历优化顾问，擅长针对不同职位提供针对性的简历改进建议。请提供具体、实用的改进建议，即使没有看到简历内容。' },
      { role: 'user', content: userPrompt }
    ];

    console.log('准备发送AI请求:', messages);

    // 调用智谱AI
    zhipuAI.callZhipuAPI(messages, {
      fallbackToMock: true,
      mockType: 'resume_advice',
      temperature: 0.9,  // 增加创造性
      onSuccess: (response, data) => {
        console.log('AI简历分析响应成功:', response);
        this.setData({
          resumeAdvice: response,
          isMockData: data.mock === true,
          isLoadingResume: false
        });
        
        // 显示成功提示
        wx.showToast({
          title: '分析完成',
          icon: 'success'
        });
      },
      onError: (error) => {
        console.error('AI响应错误:', error);
        
        // 使用默认建议
        const defaultAdvice = "建议在简历中突出与" + jobPosition + 
          "相关的技能和经验，量化成就，使用行业关键词，并确保排版清晰专业。针对不同公司定制简历内容，突出与职位描述匹配的能力。";
        
        this.setData({
          resumeAdvice: defaultAdvice,
          isMockData: true,
          isLoadingResume: false
        });
        
        wx.showToast({
          title: '使用默认建议',
          icon: 'none'
        });
      }
    });
  },

  /**
   * 查看完整优化报告
   */
  viewFullReport: function () {
    wx.showToast({
      title: '完整报告功能开发中',
      icon: 'none'
    });
  },

  /**
   * 职位选择器变化处理
   */
  bindJobChange: function (e) {
    const index = parseInt(e.detail.value);
    const isCustom = index === this.data.jobPositions.length - 1;
    
    this.setData({
      jobIndex: index,
      isCustomJob: isCustom,
      customJobName: ''  // 清空自定义名称
    });
  },
  
  /**
   * 自定义职位名称输入处理
   */
  handleCustomJobInput: function(e) {
    this.setData({
      customJobName: e.detail.value
    });
  },

  /**
   * 开始模拟面试
   */
  startMockInterview: function () {
    // 检查如果是自定义岗位，需要有输入
    if (this.data.isCustomJob && !this.data.customJobName.trim()) {
      wx.showToast({
        title: '请输入自定义岗位名称',
        icon: 'none'
      });
      return;
    }
    
    // 获取岗位名称（预设或自定义）
    const jobPosition = this.data.isCustomJob 
      ? this.data.customJobName.trim()
      : this.data.jobPositions[this.data.jobIndex];
    
    // 进入面试模式
    this.setData({
      interviewMode: true,
      isLoadingInterview: true,
      interviewMessages: [],
      interviewFeedback: '',
      isViewingHistory: false // 重置历史查看标记
    });
    
    const userPrompt = `你是面试官，正在面试我应聘${jobPosition}岗位。请开始面试，首先问我一个问题。`;
    
    const messages = [
      { role: 'system', content: `你是一位专业面试官，正在面试一位${jobPosition}岗位的应聘者。请用简洁友好的中文提问，每次只问一个问题，不要使用特殊字符和Markdown格式。面试结束时，你可以给出简短的反馈。` },
      { role: 'user', content: '你好，我来应聘这个职位，请开始面试。' }
    ];

    // 保存面试上下文
    this.setData({
      interviewContext: {
        jobPosition: jobPosition,
        messages: messages,
        startTime: new Date().toISOString() // 记录开始时间
      }
    });

    // 调用智谱AI
    zhipuAI.callZhipuAPI(messages, {
      fallbackToMock: true,
      mockType: 'interview_feedback',
      onSuccess: (response, data) => {
        console.log('AI面试官问题:', response);
        
        // 清理特殊字符
        const cleanResponse = this.cleanAIResponse(response);

        // 添加到对话历史
        const interviewMessages = [
          { role: 'ai', content: cleanResponse }
        ];
        
        this.setData({
          interviewMessages,
          isLoadingInterview: false,
          isMockData: data && data.mock === true
        });
      },
      onError: (error) => {
        console.error('AI响应错误:', error);
        wx.showToast({
          title: '获取面试问题失败',
          icon: 'none'
        });
        this.setData({
          isLoadingInterview: false,
          interviewMode: false
        });
      }
    });
  },

  /**
   * 清理AI响应中的特殊字符和格式
   */
  cleanAIResponse: function(response) {
    if (!response) return '';
    
    // 去除Markdown格式
    let cleanText = response
      .replace(/#{1,6}\s+/g, '') // 去除标题格式
      .replace(/\*\*/g, '')      // 去除加粗
      .replace(/\*/g, '')        // 去除斜体
      .replace(/`{1,3}/g, '')    // 去除代码块和行内代码
      .replace(/>\s/g, '')       // 去除引用
      .replace(/\[(.*?)\]\(.*?\)/g, '$1') // 替换链接为纯文本
      .replace(/\n{3,}/g, '\n\n'); // 将多个空行替换为最多两个
    
    return cleanText.trim();
  },

  /**
   * 处理用户输入变化
   */
  handleInputChange: function(e) {
    this.setData({
      userInput: e.detail.value
    });
  },

  /**
   * 发送用户消息
   */
  sendUserMessage: function() {
    // 首先检查是否正在加载或输入为空
    if (this.data.isLoadingInterview || !this.data.userInput.trim()) {
      if (!this.data.userInput.trim()) {
        wx.showToast({
          title: '请输入内容',
          icon: 'none'
        });
      }
      return;
    }
    
    // 获取用户输入并清空输入框
    const userMessage = this.data.userInput.trim();
    this.setData({
      userInput: '',
      isLoadingInterview: true
    });
    
    // 添加用户消息到对话历史
    const interviewMessages = [...this.data.interviewMessages, { role: 'user', content: userMessage }];
    this.setData({ interviewMessages });
    
    // 确保滚动到最新消息
    setTimeout(() => {
      // 使用选择器查找滚动视图并滚动到底部
      wx.createSelectorQuery()
        .select('.chat-messages')
        .node()
        .exec(res => {
          if (res[0] && res[0].node) {
            res[0].node.scrollIntoView({
              selector: `#msg-${interviewMessages.length-1}`,
              behavior: 'smooth'
            });
          }
        });
    }, 100);
    
    // 准备API请求消息
    const context = this.data.interviewContext;
    if (!context || !context.messages) {
      console.error('面试上下文不存在');
      this.setData({
        isLoadingInterview: false
      });
      return;
    }
    
    const messages = [...context.messages]; // 保留系统消息
    
    // 添加所有历史消息
    for (let msg of interviewMessages) {
      messages.push({
        role: msg.role === 'ai' ? 'assistant' : 'user',
        content: msg.content
      });
    }
    
    // 调用智谱AI获取回复
    zhipuAI.callZhipuAPI(messages, {
      fallbackToMock: false, // 不使用模拟数据
      onSuccess: (response, data) => {
        console.log('AI面试官回复:', response);
        
        // 清理特殊字符
        const cleanResponse = this.cleanAIResponse(response);
        
        // 添加AI回复到对话历史
        const newInterviewMessages = [...this.data.interviewMessages, { role: 'ai', content: cleanResponse }];
        
        this.setData({
          interviewMessages: newInterviewMessages,
          isLoadingInterview: false,
          isMockData: data && data.mock === true
        });
        
        // 检查是否是最后一个问题
        if (newInterviewMessages.length >= 10 || cleanResponse.includes('面试结束') || cleanResponse.includes('感谢你参加')) {
          // 保存最后的面试反馈
          this.setData({
            interviewFeedback: cleanResponse
          });
        }
      },
      onError: (error) => {
        console.error('AI响应错误:', error);
        wx.showToast({
          title: '获取面试回复失败',
          icon: 'none'
        });
        this.setData({
          isLoadingInterview: false
        });
      }
    });
  },

  /**
   * 结束面试模式
   */
  endInterviewMode: function() {
    // 如果正在查看历史记录，直接返回
    if (this.data.isViewingHistory) {
      this.setData({
        interviewMode: false,
        isViewingHistory: false
      });
      return;
    }
    
    // 如果有对话历史，生成一个总结性反馈
    if (this.data.interviewMessages.length > 0) {
      let feedback = '';
      
      // 获取最后一条AI消息作为反馈
      for (let i = this.data.interviewMessages.length - 1; i >= 0; i--) {
        if (this.data.interviewMessages[i].role === 'ai') {
          feedback = this.data.interviewMessages[i].content;
          break;
        }
      }
      
      this.setData({
        interviewFeedback: feedback
      });
      
      // 保存面试记录到历史
      const jobPosition = this.data.isCustomJob 
        ? this.data.customJobName.trim()
        : this.data.jobPositions[this.data.jobIndex];
      
      const interviewRecord = {
        jobPosition: jobPosition,
        date: new Date().toLocaleString(),
        feedback: feedback,
        messages: this.data.interviewMessages,
        context: this.data.interviewContext
      };
      
      this.saveInterviewHistory(interviewRecord);
    }
    
    this.setData({
      interviewMode: false
    });
  },

  /**
   * 行业选择器变化处理
   */
  bindIndustryChange: function (e) {
    const index = parseInt(e.detail.value);
    const isCustom = index === this.data.industries.length - 1;
    
    this.setData({
      industryIndex: index,
      isCustomIndustry: isCustom,
      customIndustryName: ''  // 清空自定义名称
    });
  },
  
  /**
   * 自定义行业名称输入处理
   */
  handleCustomIndustryInput: function(e) {
    this.setData({
      customIndustryName: e.detail.value
    });
  },

  /**
   * 分析行业趋势
   */
  analyzeIndustryTrend: function () {
    // 检查如果是自定义行业，需要有输入
    if (this.data.isCustomIndustry && !this.data.customIndustryName.trim()) {
      wx.showToast({
        title: '请输入自定义行业名称',
        icon: 'none'
      });
      return;
    }
    
    // 获取行业名称（预设或自定义）
    const industry = this.data.isCustomIndustry 
      ? this.data.customIndustryName.trim()
      : this.data.industries[this.data.industryIndex];
    
    // 显示加载效果 - 只更新行业趋势的加载状态
    this.setData({
      isLoadingIndustry: true
    });
    
    const userPrompt = `请分析${industry}行业近期的发展趋势、人才需求和薪资水平。`;
    
    const messages = [
      { role: 'system', content: '你是一个专业的行业分析师，擅长分析不同行业的发展趋势和人才需求情况。' },
      { role: 'user', content: userPrompt }
    ];

    // 调用智谱AI
    zhipuAI.callZhipuAPI(messages, {
      fallbackToMock: true,
      mockType: 'industry_trend',
      onSuccess: (response, data) => {
        console.log('AI行业趋势响应成功:', response);
        this.setData({
          industryTrend: response,
          isMockData: data.mock === true,
          isLoadingIndustry: false
        });
      },
      onError: (error) => {
        console.error('AI响应错误:', error);
        wx.showToast({
          title: '获取行业分析失败',
          icon: 'none'
        });
        this.setData({
          isLoadingIndustry: false
        });
      }
    });
  },
  
  /**
   * 用户点击右上角分享
   */
  onShareAppMessage: function () {
    return {
      title: '生涯规划助手 - 科学规划你的职业发展',
      path: '/pages/career_guide/career_guide'
    };
  }
}); 